home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / amok / amok_lha / amok72.lha / while-Interpreter / Source / QuadInterpreter.MOD < prev    next >
Text File  |  1993-08-15  |  18KB  |  629 lines
  1. (******************************
  2.  * Programm von Dieter Seidel *
  3.  *  Eingegeben am 14.11.1991  *
  4.  * Nach einer langen Pause    *
  5.  * fertiggestellt am 23.07.92 *
  6.  ******************************)
  7.  
  8.  
  9. IMPLEMENTATION MODULE QuadInterpreter;
  10.  
  11. FROM InOut            IMPORT ReadCard, WriteCard, WriteLn, Write, WriteString;
  12. FROM LongInOut        IMPORT WriteLongCard;
  13. FROM JaNein           IMPORT JaNein;
  14. FROM QuadLese         IMPORT MaxZeile, QuadZeile, arrQuad, arrList;
  15. FROM QuadDrucke       IMPORT DruckeQuadrupel;
  16. FROM QuadBerechneQuad IMPORT BerechneQuad;
  17.  
  18. CONST Max    = 100;  (* Die Variablen X[0]..X[99] sind für while-Programme  *)
  19.                      (* gedacht, während X[100] für Konstanten in den       *)
  20.                      (* while-Programmen sind.                              *)
  21.       MaxVar = 4;
  22.  
  23. VAR   X              : ARRAY [0..Max] OF CARDINAL;
  24.       AnzAnweisungen : LONGCARD;
  25.  
  26.  
  27. PROCEDURE DruckeVariable(VAR X : ARRAY OF CARDINAL);
  28. VAR i, Anzahl : CARDINAL;
  29. BEGIN
  30.   Anzahl:=0;
  31.   FOR i:=0 TO 99 DO        (* Bis Max, aber X[Max] steht für die Zahl null. *)
  32.     IF X[i] # 0 THEN
  33.       WriteString("  X[");WriteCard(i,2);WriteString("] : ");
  34.       WriteCard(X[i],5);
  35.       INC(Anzahl);
  36.       IF Anzahl = MaxVar THEN
  37.         WriteLn;
  38.         Anzahl:=0;
  39.       ELSE
  40.         WriteString(" : ");
  41.       END;
  42.     END;
  43.   END;
  44.   IF Anzahl # 0 THEN
  45.     WriteLn;
  46.   END;
  47. END DruckeVariable;
  48.  
  49.  
  50. PROCEDURE HoleVariable(    QuadListe        : arrQuad;
  51.                            Zaehler          : CARDINAL;
  52.                        VAR VarEins, VarZwei : CARDINAL);
  53. VAR i : CARDINAL;
  54. BEGIN
  55.   i:=2;
  56.   VarEins:=0;
  57.   VarZwei:=0;
  58.   WHILE (QuadListe[Zaehler].Befehl[i] >= "0") AND
  59.         (QuadListe[Zaehler].Befehl[i] <= "9") AND (i <= MaxZeile) DO
  60.     VarEins:=VarEins * 10;
  61.     VarEins:=VarEins + ORD(QuadListe[Zaehler].Befehl[i]) - ORD("0");
  62.     INC(i);
  63.   END;
  64.   IF VarEins > 99 THEN
  65.     WriteLn;
  66.     WriteString("Zu grosser Variablen-Index!!! ");
  67.     DruckeQuadrupel(QuadListe[Zaehler]);
  68.     WriteLn;
  69.     HALT;
  70.   END;
  71.   WHILE NOT((QuadListe[Zaehler].Befehl[i] >= "0")  AND
  72.             (QuadListe[Zaehler].Befehl[i] <= "9")) AND
  73.             (QuadListe[Zaehler].Befehl[i] # "X")   AND
  74.             (i <= MaxZeile)                              DO
  75.     INC(i);
  76.   END;
  77.   IF i > MaxZeile THEN
  78.     WriteLn;
  79.     WriteString("Vermisse die zweite Anweisung!!!");
  80.     DruckeQuadrupel(QuadListe[Zaehler]);
  81.     WriteLn;
  82.     HALT;
  83.   END;
  84.   IF (QuadListe[Zaehler].Befehl[i] >= "0") AND
  85.      (QuadListe[Zaehler].Befehl[i] <= "9") THEN
  86.     X[Max]:=0;
  87.     WHILE (QuadListe[Zaehler].Befehl[i] >= "0") AND
  88.           (QuadListe[Zaehler].Befehl[i] <= "9") AND (i <= MaxZeile) DO
  89.       X[Max]:=10*X[Max];
  90.       X[Max]:=X[Max] + ORD(QuadListe[Zaehler].Befehl[i]) - ORD("0");
  91.       INC(i);
  92.     END;
  93.     VarZwei:=Max;
  94.   ELSE
  95.     INC(i);
  96.     IF i > MaxZeile THEN
  97.       WriteLn;
  98.       WriteString("Vermisse die zweite Anweisung!!!");
  99.       DruckeQuadrupel(QuadListe[Zaehler]);
  100.       WriteLn;
  101.       HALT;
  102.     END;
  103.     WHILE (QuadListe[Zaehler].Befehl[i] >= "0") AND
  104.           (QuadListe[Zaehler].Befehl[i] <= "9") AND (i <= MaxZeile) DO
  105.       VarZwei:=VarZwei * 10;
  106.       VarZwei:=VarZwei + ORD(QuadListe[Zaehler].Befehl[i]) - ORD("0");
  107.       INC(i);
  108.     END;
  109.     IF VarZwei > 99 THEN
  110.       WriteLn;
  111.       WriteString("Zu grosser Variablen-Index!!! ");
  112.       DruckeQuadrupel(QuadListe[Zaehler]);
  113.       WriteLn;
  114.       HALT;
  115.     END;
  116.   END;
  117. END HoleVariable;
  118.  
  119.  
  120. PROCEDURE succ(Zeile : QuadZeile) : BOOLEAN;
  121. VAR i : CARDINAL;
  122. BEGIN
  123.   FOR i:=1 TO MaxZeile DO
  124.     IF Zeile.Befehl[i] = "s" THEN
  125.       RETURN TRUE;
  126.     END;
  127.   END;
  128.   RETURN FALSE;
  129. END succ;
  130.  
  131.  
  132. PROCEDURE pred(Zeile : QuadZeile) : BOOLEAN;
  133. VAR i : CARDINAL;
  134. BEGIN
  135.   FOR i:=1 TO MaxZeile DO
  136.     IF Zeile.Befehl[i] = "p" THEN
  137.       RETURN TRUE;
  138.     END;
  139.   END;
  140.   RETURN FALSE;
  141. END pred;
  142.  
  143.  
  144. PROCEDURE schleife(Zeile : QuadZeile) : BOOLEAN;
  145. VAR i : CARDINAL;
  146. BEGIN
  147.   FOR i:=1 TO MaxZeile DO
  148.     IF Zeile.Befehl[i] = "#" THEN
  149.       RETURN TRUE;
  150.     END;
  151.   END;
  152.   RETURN FALSE;
  153. END schleife;
  154.  
  155.  
  156. PROCEDURE UnterprogrammNr(Zeile : QuadZeile) : CARDINAL;
  157. VAR i,
  158.     Nummer : CARDINAL;
  159. BEGIN
  160.   Nummer:=0;
  161.   i:=2;
  162.   WHILE (Zeile.Befehl[i] >= "0") AND
  163.         (Zeile.Befehl[i] <= "9") AND (i <= MaxZeile) DO
  164.     Nummer:=Nummer * 10;
  165.     Nummer:=Nummer + ORD(Zeile.Befehl[i]) - ORD("0");
  166.     INC(i);
  167.   END;
  168.   RETURN Nummer;
  169. END UnterprogrammNr;
  170.  
  171.  
  172. PROCEDURE BerUnterPrg(PrgNummer, Tiefe : CARDINAL;
  173.                       QuadLst          : arrQuad;
  174.                       ZeigeUnterPrg    : BOOLEAN);
  175. VAR   i,
  176.       VarEins,
  177.       VarZwei,
  178.       Anzahl,
  179.       Zaehler    : CARDINAL; (* Zeigt auf die auszufuehrende Quadrupelzeile *)
  180.       QuadLst2   : arrQuad;
  181.       BefehlsLst : arrList;
  182.       Korrekt    : BOOLEAN;
  183.       Y          : ARRAY [0..Max] OF CARDINAL;
  184. BEGIN
  185.   FOR i:=0 TO 9 DO
  186.     Y[i]:=X[i];
  187.   END;
  188.   FOR i:=10 TO Max DO
  189.     Y[i]:=0;
  190.   END;
  191.   Zaehler:=1;
  192.   Anzahl:=1;
  193.  
  194.   WHILE QuadLst[Zaehler].Zeile # 0 DO
  195.     Korrekt:=FALSE;
  196.  
  197.     IF ZeigeUnterPrg THEN
  198.       IF PrgNummer = 1 THEN
  199.         WriteString("Add");
  200.       END;
  201.       IF PrgNummer = 2 THEN
  202.         WriteString("Sub");
  203.       END;
  204.       IF PrgNummer = 3 THEN
  205.         WriteString("Mul");
  206.       END;
  207.       IF PrgNummer = 4 THEN
  208.         WriteString("DIV");
  209.       END;
  210.       IF PrgNummer = 5 THEN
  211.         WriteString("MOD");
  212.       END;
  213.       WriteCard(Tiefe,1);
  214.       WriteString(" : ");
  215.       WriteCard(Anzahl,3);
  216.       WriteString(" Quad : ");
  217.       DruckeQuadrupel(QuadLst[Zaehler]);
  218.     END;
  219.  
  220.     IF QuadLst[Zaehler].Befehl[1] = "U" THEN
  221.       VarEins:=UnterprogrammNr(QuadLst[Zaehler]);
  222.       IF VarEins = 1 THEN
  223.         IF ZeigeUnterPrg THEN
  224.           WriteString("  U1 ---> Addition       : X1:=X1+X2");WriteLn;
  225.         END;
  226.         BefehlsLst:="bX10:X2;wX10#0dbX10:p(X10);X1:s(X1)ee";
  227.         BerechneQuad(BefehlsLst,QuadLst2);
  228.         FOR i:=1 TO 9 DO X[i]:=Y[i]; END;
  229.         BerUnterPrg(VarEins,Tiefe+1,QuadLst2,ZeigeUnterPrg);
  230.         FOR i:=1 TO 9 DO Y[i]:=X[i]; END;
  231.       END;
  232.  
  233.       IF VarEins = 2 THEN
  234.         IF ZeigeUnterPrg THEN
  235.           WriteString("  U2 ---> Subtraktion    : X1:=X1-X2");WriteLn;
  236.         END;
  237.         BefehlsLst:="bX10:X2;wX10#0dbX10:p(X10);X1:p(X1)ee";
  238.         BerechneQuad(BefehlsLst,QuadLst2);
  239.         FOR i:=1 TO 9 DO X[i]:=Y[i]; END;
  240.         BerUnterPrg(VarEins,Tiefe+1,QuadLst2,ZeigeUnterPrg);
  241.         FOR i:=1 TO 9 DO Y[i]:=X[i]; END;
  242.       END;
  243.  
  244.       IF VarEins = 3 THEN
  245.         IF ZeigeUnterPrg THEN
  246.           WriteString("  U3 ---> Multiplikation : X1:=X1*X2");WriteLn;
  247.         END;
  248.         BefehlsLst:="bX10:p(X1);X1:X2;wX10#0dbU1;X10:p(X10);ee";
  249.         BerechneQuad(BefehlsLst,QuadLst2);
  250.         FOR i:=1 TO 9 DO X[i]:=Y[i]; END;
  251.         BerUnterPrg(VarEins,Tiefe+1,QuadLst2,ZeigeUnterPrg);
  252.         FOR i:=1 TO 9 DO Y[i]:=X[i]; END;
  253.       END;
  254.  
  255.       IF VarEins = 4 THEN
  256.         IF ZeigeUnterPrg THEN
  257.           WriteString("  U4 ---> Division       : X1:=X1 DIV X2");WriteLn;
  258.         END;
  259.         BefehlsLst:="bX10:0;X11:s(X1);X12:X1;X1:X11;U2;X11:X1;X1:X12;wX11#0dbU2;X10:s(X10);X11:s(X1);X12:X1;X1:X11;U2;X11:X1;X1:X12eX1:X10e";
  260.         BerechneQuad(BefehlsLst,QuadLst);
  261.  
  262. (*Drucke(BefehlsLst,QuadLst);WriteLn;*)
  263.  
  264.         FOR i:=1 TO 9 DO X[i]:=Y[i]; END;
  265.         BerUnterPrg(VarEins,Tiefe+1,QuadLst2,ZeigeUnterPrg);
  266.         FOR i:=1 TO 9 DO Y[i]:=X[i]; END;
  267.       END;
  268.  
  269.       IF VarEins = 5 THEN
  270.         IF ZeigeUnterPrg THEN
  271.           WriteString("  U5 ---> Modular        : X1:=X1 MOD X2");WriteLn;
  272.         END;
  273.         BefehlsLst:="bX10:0;X11:s(X1);X12:X1;X1:X11;U2;X11:X1;X1:X12;wX11#0dbU2;X10:s(X10);X11:s(X1);X12:X1;X1:X11;U2;X11:X1;X1:X12ee";
  274.         BerechneQuad(BefehlsLst,QuadLst);
  275.         FOR i:=1 TO 9 DO X[i]:=Y[i]; END;
  276.         BerUnterPrg(VarEins,Tiefe+1,QuadLst2,ZeigeUnterPrg);
  277.         FOR i:=1 TO 9 DO Y[i]:=X[i]; END;
  278.       END;
  279.  
  280.       Zaehler:=QuadLst[Zaehler].IFzeile;
  281.       Korrekt:=TRUE;
  282.     ELSE
  283.       HoleVariable(QuadLst,Zaehler,VarEins,VarZwei);
  284.       Y[Max]:=X[Max];
  285.     END;
  286.  
  287.     IF NOT(Korrekt) AND succ(QuadLst[Zaehler]) THEN
  288.       IF Y[VarZwei] # 65535 THEN
  289.         Y[VarEins]:=Y[VarZwei]+1;
  290.       ELSE
  291.         Y[VarEins]:=65535;
  292.       END;
  293.       Korrekt:=TRUE;
  294.       Zaehler:=QuadLst[Zaehler].IFzeile;
  295.       IF ZeigeUnterPrg THEN
  296.         WriteString("  succ(X");
  297.         WriteCard(VarZwei,1);
  298.         WriteString(")       ---> X");
  299.         WriteCard(VarEins,1);
  300.         WriteString(" = ");
  301.         WriteCard(Y[VarEins],1);WriteLn;
  302.       END;
  303.     END;
  304.  
  305.     IF NOT(Korrekt) AND pred(QuadLst[Zaehler]) THEN
  306.       IF Y[VarZwei] # 0 THEN
  307.         Y[VarEins]:=Y[VarZwei]-1;
  308.       ELSE
  309.         Y[VarEins]:=0;
  310.       END;
  311.       Korrekt:=TRUE;
  312.       Zaehler:=QuadLst[Zaehler].IFzeile;
  313.       IF ZeigeUnterPrg THEN
  314.         WriteString("  pred(X");
  315.         WriteCard(VarZwei,1);
  316.         WriteString(")       ---> X");
  317.         WriteCard(VarEins,1);
  318.         WriteString(" = ");
  319.         WriteCard(Y[VarEins],1);WriteLn;
  320.       END;
  321.     END;
  322.  
  323.     IF NOT(Korrekt) AND schleife(QuadLst[Zaehler]) THEN
  324.       IF Y[VarEins] # Y[VarZwei] THEN
  325.         Zaehler:=QuadLst[Zaehler].IFzeile;
  326.         IF ZeigeUnterPrg THEN
  327.           WriteString("  while X");
  328.           WriteCard(VarEins,1);
  329.           WriteString(" # ");
  330.         IF VarZwei = Max THEN
  331.           WriteCard(Y[Max],1);
  332.         ELSE
  333.           Write("X");
  334.           WriteCard(VarZwei,1);
  335.         END;
  336.           WriteString("  ---> TRUE");
  337.           WriteLn;
  338.         END;
  339.       ELSE
  340.         Zaehler:=QuadLst[Zaehler].ELSEzeile;
  341.         IF ZeigeUnterPrg THEN
  342.           WriteString("  while X");
  343.           WriteCard(VarEins,1);
  344.           WriteString(" # ");
  345.           IF VarZwei = Max THEN
  346.             WriteCard(Y[Max],1);
  347.           ELSE
  348.             Write("X");
  349.             WriteCard(VarZwei,1);
  350.           END;
  351.           WriteString("  ---> FALSE");
  352.           WriteLn;
  353.         END;
  354.       END;
  355.       Korrekt:=TRUE;
  356.     END;
  357.  
  358.     IF NOT(Korrekt) THEN
  359.       Y[VarEins]:=Y[VarZwei];
  360.       Korrekt:=TRUE;
  361.       Zaehler:=QuadLst[Zaehler].IFzeile;
  362.       IF ZeigeUnterPrg THEN
  363.         WriteString("  X");
  364.         WriteCard(VarEins,1);
  365.         WriteString(":=");
  366.         IF VarZwei = Max THEN
  367.           WriteCard(Y[Max],1);
  368.         ELSE
  369.           Write("X");
  370.           WriteCard(VarZwei,1);
  371.         END;
  372.         WriteString("          ---> X");
  373.         WriteCard(VarEins,1);
  374.         WriteString(" = ");
  375.         WriteCard(Y[VarEins],1);
  376.         WriteLn;
  377.       END;
  378.     END;
  379.  
  380.     INC(Anzahl);
  381.     INC(AnzAnweisungen);
  382.   END;
  383.   FOR i:=0 TO 9 DO
  384.     X[i]:=Y[i];
  385.   END;
  386. END BerUnterPrg;
  387.  
  388.  
  389. PROCEDURE Unterprogramm(ZeigeBefehl, ZeigeUnterPrg : BOOLEAN;
  390.                         Nummer : CARDINAL);
  391. VAR QuadLst    : arrQuad;
  392.     BefehlsLst : arrList;
  393. BEGIN
  394.   IF Nummer = 1 THEN
  395.     IF ZeigeBefehl THEN
  396.       WriteString("  U1 ---> Addition       : X1:=X1+X2");WriteLn;
  397.     END;
  398.     BefehlsLst:="bX10:X2;wX10#0dbX10:p(X10);X1:s(X1)ee";
  399.     BerechneQuad(BefehlsLst,QuadLst);
  400.     BerUnterPrg(Nummer,1,QuadLst,ZeigeUnterPrg);
  401.   END;
  402.  
  403.   IF Nummer = 2 THEN
  404.     IF ZeigeBefehl THEN
  405.       WriteString("  U2 ---> Subtraktion    : X1:=X1-X2");WriteLn;
  406.     END;
  407.     BefehlsLst:="bX10:X2;wX10#0dbX10:p(X10);X1:p(X1)ee";
  408.     BerechneQuad(BefehlsLst,QuadLst);
  409.     BerUnterPrg(Nummer,1,QuadLst,ZeigeUnterPrg);
  410.   END;
  411.  
  412.   IF Nummer = 3 THEN
  413.     IF ZeigeBefehl THEN
  414.       WriteString("  U3 ---> Multiplikation : X1:=X1*X2");WriteLn;
  415.     END;
  416.     BefehlsLst:="bX10:p(X1);X1:X2;wX10#0dbU1;X10:p(X10);ee";
  417.     BerechneQuad(BefehlsLst,QuadLst);
  418.     BerUnterPrg(Nummer,1,QuadLst,ZeigeUnterPrg);
  419.   END;
  420.  
  421.   IF Nummer = 4 THEN
  422.     IF ZeigeBefehl THEN
  423.       WriteString("  U4 ---> Division       : X1:=X1 DIV X2");WriteLn;
  424.     END;
  425.     BefehlsLst:="bX10:0;X11:s(X1);X12:X1;X1:X11;U2;X11:X1;X1:X12;wX11#0dbU2;X10:s(X10);X11:s(X1);X12:X1;X1:X11;U2;X11:X1;X1:X12eX1:X10e";
  426.     BerechneQuad(BefehlsLst,QuadLst);
  427.  
  428. (*Drucke(BefehlsLst,QuadLst);WriteLn;*)
  429.  
  430.     BerUnterPrg(Nummer,1,QuadLst,ZeigeUnterPrg);
  431.   END;
  432.  
  433.   IF Nummer = 5 THEN
  434.     IF ZeigeBefehl THEN
  435.       WriteString("  U5 ---> Modular        : X1:=X1 MOD X2");WriteLn;
  436.     END;
  437.     BefehlsLst:="bX10:0;X11:s(X1);X12:X1;X1:X11;U2;X11:X1;X1:X12;wX11#0dbU2;X10:s(X10);X11:s(X1);X12:X1;X1:X11;U2;X11:X1;X1:X12ee";
  438.     BerechneQuad(BefehlsLst,QuadLst);
  439.     BerUnterPrg(Nummer,1,QuadLst,ZeigeUnterPrg);
  440.   END;
  441.  
  442.   IF (Nummer < 1) AND (Nummer > 5) THEN
  443.     WriteString(" U");WriteCard(Nummer,1);
  444.     WriteString(" existiert nicht!!!");
  445.     WriteLn;
  446.   END;
  447.  
  448. END Unterprogramm;
  449.  
  450.  
  451. PROCEDURE Interpreter(QuadListe : arrQuad);
  452. VAR   i,
  453.       VarEins,
  454.       VarZwei,
  455.       Anw,                (* Bisher ausgefuehrte Anweisungen.   *)
  456.       AnwMax,             (* Maximal auszufuehrende Anweisungen *)
  457.       Zaehler : CARDINAL; (* Zeigt auf die auszufuehrende Quadrupelzeile *)
  458.       ZeigeBefehl,
  459.       ZeigeUnterPrg,
  460.       ZeigeVariable,
  461.       Korrekt : BOOLEAN;
  462.  
  463.  
  464. BEGIN
  465.   FOR i:=0 TO Max DO;
  466.     X[i]:=0;
  467.   END;
  468.   WriteLn;
  469.   WriteString("Soll dieses while-Programm ausgefuehrt werden ? ");
  470.   IF JaNein() THEN
  471.     Zaehler:=1;
  472.     WriteString("Wieviele Anweisungen sollen maximal ausgefuehrt werden : ");
  473.     ReadCard(AnwMax);
  474.     IF AnwMax >= 65534 THEN AnwMax:=65534 END;
  475.     WriteCard(AnwMax,1);WriteLn;
  476.     WriteString("Soll jede einzelne Anweisung gedruckt werden ? ");
  477.     ZeigeBefehl:=JaNein();
  478.     IF ZeigeBefehl THEN
  479.       WriteString("Sollen dann auch die Variablen # 0 gedruckt werden ? ");
  480.       ZeigeVariable:=JaNein();
  481.       WriteString("Sollen die Anweisungen der Unterprogramme gezeigt ");
  482.       WriteString("werden ? ");
  483.       ZeigeUnterPrg:=JaNein();
  484.     ELSE
  485.       ZeigeVariable:=FALSE;
  486.     END;
  487.     
  488.     Anw:=1;
  489.     AnzAnweisungen:=0;
  490.     WHILE Anw <= AnwMax DO
  491.       Korrekt:=FALSE;
  492.       
  493.       IF QuadListe[Zaehler].Zeile = 0 THEN
  494.         WriteLn;
  495.         WriteString("Ende der Quadrupelliste --> Ende des Programms.");
  496.         WriteLn;
  497.         Korrekt:=TRUE;
  498.         Anw:=AnwMax + 1;
  499.       ELSE
  500.       
  501.         IF ZeigeBefehl THEN
  502.           WriteString("Main : ");WriteCard(Anw,3);
  503.           WriteString(" Quad : ");
  504.           DruckeQuadrupel(QuadListe[Zaehler]);
  505.         END;
  506.         
  507.         IF QuadListe[Zaehler].Befehl[1] = "U" THEN
  508.           Unterprogramm(ZeigeBefehl,ZeigeUnterPrg,
  509.                         UnterprogrammNr(QuadListe[Zaehler]));
  510.           Zaehler:=QuadListe[Zaehler].IFzeile;
  511.           Korrekt:=TRUE;
  512.         ELSE
  513.           HoleVariable(QuadListe,Zaehler,VarEins,VarZwei);
  514.         END;
  515.       
  516.         IF NOT(Korrekt) AND succ(QuadListe[Zaehler]) THEN
  517.           IF X[VarZwei] # 65535 THEN
  518.             X[VarEins]:=X[VarZwei]+1;
  519.           ELSE
  520.             X[VarEins]:=65535;
  521.           END;
  522.           Korrekt:=TRUE;
  523.           Zaehler:=QuadListe[Zaehler].IFzeile;
  524.           IF ZeigeBefehl THEN
  525.             WriteString("  succ(X");
  526.             WriteCard(VarZwei,1);
  527.             WriteString(")       ---> X");
  528.             WriteCard(VarEins,1);
  529.             WriteString(" = ");
  530.             WriteCard(X[VarEins],1);WriteLn;
  531.           END;
  532.         END;
  533.        
  534.         IF NOT(Korrekt) AND pred(QuadListe[Zaehler]) THEN
  535.           IF X[VarZwei] # 0 THEN
  536.             X[VarEins]:=X[VarZwei]-1;
  537.           ELSE
  538.             X[VarEins]:=0;
  539.           END;
  540.           Korrekt:=TRUE;
  541.           Zaehler:=QuadListe[Zaehler].IFzeile;
  542.           IF ZeigeBefehl THEN
  543.             WriteString("  pred(X");
  544.             WriteCard(VarZwei,1);
  545.             WriteString(")       ---> X");
  546.             WriteCard(VarEins,1);
  547.             WriteString(" = ");
  548.             WriteCard(X[VarEins],1);WriteLn;
  549.           END;
  550.         END;
  551.         
  552.         IF NOT(Korrekt) AND schleife(QuadListe[Zaehler]) THEN
  553.           IF X[VarEins] # X[VarZwei] THEN
  554.             Zaehler:=QuadListe[Zaehler].IFzeile;
  555.             IF ZeigeBefehl THEN
  556.               WriteString("  while X");
  557.               WriteCard(VarEins,1);
  558.               WriteString(" # ");
  559.               IF VarZwei = Max THEN
  560.                 WriteCard(X[Max],1);
  561.               ELSE
  562.                 Write("X");
  563.                 WriteCard(VarZwei,1);
  564.               END;
  565.               WriteString("  ---> TRUE");
  566.               WriteLn;
  567.             END;
  568.           ELSE
  569.             Zaehler:=QuadListe[Zaehler].ELSEzeile;
  570.             IF ZeigeBefehl THEN
  571.               WriteString("  while X");
  572.               WriteCard(VarEins,1);
  573.               WriteString(" # ");
  574.               IF VarZwei = Max THEN
  575.                 WriteCard(X[Max],1);
  576.               ELSE
  577.                 Write("X");
  578.                 WriteCard(VarZwei,1);
  579.               END;
  580.               WriteString("  ---> FALSE");
  581.               WriteLn;
  582.             END;
  583.           END;
  584.           Korrekt:=TRUE;
  585.         END;
  586.         
  587.         IF NOT(Korrekt) THEN
  588.           X[VarEins]:=X[VarZwei];
  589.           Korrekt:=TRUE;
  590.           Zaehler:=QuadListe[Zaehler].IFzeile;
  591.           IF ZeigeBefehl THEN
  592.             WriteString("  X");
  593.             WriteCard(VarEins,1);
  594.             WriteString(":=");
  595.             IF VarZwei = Max THEN
  596.               WriteCard(X[Max],1);
  597.             ELSE
  598.               Write("X");
  599.               WriteCard(VarZwei,1);
  600.             END;
  601.             WriteString("          ---> X");
  602.             WriteCard(VarEins,1);
  603.             WriteString(" = ");
  604.             WriteCard(X[VarEins],1);
  605.             WriteLn;
  606.           END;
  607.         END;
  608.       
  609.         IF ZeigeVariable THEN
  610.           DruckeVariable(X);
  611.           WriteLn;
  612.         END;
  613.       
  614.         INC(AnzAnweisungen);
  615.         INC(Anw);
  616.       END;
  617.     END;
  618.     
  619.     WriteLn;WriteLn;
  620.     WriteString("Es wurden ");WriteLongCard(AnzAnweisungen,1);
  621.     WriteString(" Anweisungen ausgefuehrt.");WriteLn;
  622.     WriteString("Ergebnis : ");WriteLn;
  623.     DruckeVariable(X);
  624.   END;
  625. END Interpreter;
  626.  
  627.  
  628. END QuadInterpreter.
  629.